
#ifndef THREAD_SAFE_H
#define THREAD_SAFE_H

#include <mutex>
#include <condition_variable>
#include <queue>
#include <atomic>

namespace TimeoutManager {

    // 线程安全的队列
    template<typename T>
    class ThreadSafeQueue {
    private:
        mutable std::mutex mutex_;           // 保护队列的互斥锁
        std::queue<T> queue_;               // 内部队列
        std::condition_variable condition_; // 条件变量，用于通知

    public:
        ThreadSafeQueue() = default;

        // 禁用拷贝构造和赋值
        ThreadSafeQueue(const ThreadSafeQueue&) = delete;
        ThreadSafeQueue& operator=(const ThreadSafeQueue&) = delete;

        // 向队列添加元素
        void push(T item) {
            std::lock_guard<std::mutex> lock(mutex_);
            queue_.push(item);
            condition_.notify_one(); // 通知等待的线程
        }

        // 等待并弹出元素（阻塞版本）
        void waitAndPop(T& item) {
            std::unique_lock<std::mutex> lock(mutex_);
            while (queue_.empty()) {
                condition_.wait(lock); // 等待队列有元素
            }
            item = queue_.front();
            queue_.pop();
        }

        // 尝试弹出元素（非阻塞版本）
        bool tryPop(T& item) {
            std::lock_guard<std::mutex> lock(mutex_);
            if (queue_.empty()) {
                return false;
            }
            item = queue_.front();
            queue_.pop();
            return true;
        }

        // 检查队列是否为空
        bool empty() const {
            std::lock_guard<std::mutex> lock(mutex_);
            return queue_.empty();
        }

        // 获取队列大小
        size_t size() const {
            std::lock_guard<std::mutex> lock(mutex_);
            return queue_.size();
        }
    };

    // 原子计数器类
    class AtomicCounter {
    private:
        std::atomic<uint64_t> counter_{0}; // 原子计数器

    public:
        // 获取下一个计数值
        uint64_t next() {
            return counter_.fetch_add(1) + 1;
        }

        // 获取当前计数值
        uint64_t current() const {
            return counter_.load();
        }

        // 重置计数器
        void reset() {
            counter_.store(0);
        }
    };

} // namespace TimeoutManager

#endif // THREAD_SAFE_H
